home *** CD-ROM | disk | FTP | other *** search
/ Info-Mac 4 / Info_Mac IV CD-ROM (Pacific HiTech Inc.)(August 1994).iso / Development / General / MM3Tp.sea Folder / Made by Marksman / Sources / mm / mmW_Floating_window.p < prev    next >
Text File  |  1994-01-16  |  12KB  |  422 lines
  1.  
  2. Unit mmW_Floating_window;
  3. {  mmW_Floating_window                                 Handle this Window }
  4. {  Copyright © 1994 George R. Cossey }
  5.  
  6. { 
  7.     File name: mmW_Floating_window
  8.     Function: Handle a Window 
  9.     History: 1/16/94 Original by George Cossey
  10.  
  11. }
  12.  
  13. interface
  14.  
  15.     uses
  16.         Printing,Folders,Sound,mmCommonMM_Demo,CommonMM_Demo,
  17.         {}
  18.         mmPA_My_Alert,
  19.         {}
  20.         mmD_My_Modal,
  21.         {}
  22.         mmMD_My_Movable_Moda,
  23.         mmMD_My_Modeless,
  24.         mmMD_About_Demo,
  25.         {}
  26.         UFloating_window;
  27.  
  28. procedure Init_Floating_window;
  29. procedure Close_Floating_window(whichWindow:WindowPtr);
  30. procedure Resized_Floating_window(OldRect:Rect;whichWindow:WindowPtr);
  31. procedure Update_Floating_window(whichWindow:WindowPtr);
  32. procedure Open_Floating_window;
  33. procedure Activate_Floating_window(whichWindow:WindowPtr;Do_An_Activate:Boolean);
  34. procedure Do_Floating_window(var myEvent:EventRecord);
  35.  
  36. { ======================================================= }
  37. { ======================================================= }
  38.  
  39. implementation
  40.  
  41.  
  42. { ======================================================= }
  43. { ======================================================= }
  44.  
  45.  
  46. procedure InitRecord(theWS:Floating_windowPRec);
  47.  
  48.  
  49. begin
  50. theWS^.theWindow := nil;                    { Make sure other routines know we are not valid yet }
  51.  
  52. { Set the window back color }
  53. theWS^.WindowBackColor.red  := $FFFF;  
  54. theWS^.WindowBackColor.green  := $FFFF;  
  55. theWS^.WindowBackColor.blue  := $FFFF;
  56.  
  57. theWS^.Enable_Tool_palette2 := true;                { Palette, Tool palette  }
  58. theWS^.Value_Tool_palette2 := 0;
  59.  
  60. U_InitFloating_windowRec(theWS);                            { Call user init routine }
  61. end;
  62.  
  63. { ======================================================= }
  64.  
  65. procedure LocateInstance(theWindow:WindowPtr);
  66. var
  67.     ckWS,theWS:Floating_windowPRec;
  68.  
  69.  
  70. begin
  71. theWS := nil;                            { Init to not found }
  72. ckWS := ListRecPtr_Floating_window;
  73. while (ckWS <> nil) do
  74.     begin
  75.     if (ckWS^.theWindow = theWindow) then
  76.         theWS := ckWS;
  77.     ckWS := ckWS^.Next;
  78.     end;
  79. RecPtr_Floating_window := theWS;
  80. end;
  81.  
  82. { ======================================================= }
  83.  
  84. { Routine: Init_Floating_window }
  85. { Purpose: Initialize our window data to not in use yet }
  86.  
  87. procedure Init_Floating_window;
  88.  
  89.  
  90. begin
  91. theWindowLocRec.Loc_Floating_window.h := 24;            { Set default Horz position }
  92. theWindowLocRec.Loc_Floating_window.v := 45;            { Set default Vert position }
  93.  
  94. RecPtr_Floating_window := nil;                        { No open windows yet }
  95. ListRecPtr_Floating_window := nil;
  96. MultipleAllowed_Floating_window := true;            { Init to allow multiple instances }
  97.  
  98. U_InitFloating_window;                                { Call the user window init routine }
  99. end;
  100.  
  101. { ======================================================= }
  102.  
  103. { Routine: Close_Floating_window }
  104. { Purpose: Close out the window }
  105.  
  106. procedure Close_Floating_window(whichWindow:WindowPtr);
  107. var
  108.     ckWS,theWS:Floating_windowPRec;
  109.  
  110.  
  111. begin
  112. if (whichWindow = WindowPtr(-1)) then
  113.     whichWindow := FrontWindow;
  114.     
  115. LocateInstance(whichWindow);
  116.  
  117. { See if we should close this window }
  118. if (RecPtr_Floating_window <> nil) then
  119.     begin
  120.     theWS := RecPtr_Floating_window;
  121.     
  122.     U_CloseFloating_window(theWS);                    { Call the user window close routine }
  123.  
  124.     SetPort(whichWindow);                            { Select our window }
  125.     theWindowLocRec.Loc_Floating_window.h := 0;        { Reset Horz position }
  126.     theWindowLocRec.Loc_Floating_window.v := 0;        { Reset Vert position }
  127.     LocalToGlobal(theWindowLocRec.Loc_Floating_window);    { Get global location }
  128.  
  129.     Mk_CloseLayeredWindow(whichWindow);                { Notify the layer code that we are closing }
  130.  
  131.     DisposeWindow(whichWindow);                        { Clear window and controls }
  132.  
  133.     ckWS := ListRecPtr_Floating_window;
  134.     if (ckWS = theWS) then                                { See if first in the list }
  135.         begin
  136.         ListRecPtr_Floating_window := theWS^.Next;    { Use second one as new first }
  137.         DisposePtr(Ptr(theWS));                        { Get rid of this one }
  138.         end
  139.     else
  140.         begin
  141.         while (ckWS <> nil) do                        { Loop thru them all }
  142.             begin
  143.             if (ckWS^.Next = theWS) then                { See if the next one is a match }
  144.                 begin
  145.                 ckWS^.Next := theWS^.Next;            { Get new next one }
  146.                 DisposePtr(Ptr(theWS));                { Get rid of this one }
  147.                 ckWS := nil;                            { Get us out of the loop }
  148.                 end
  149.             else
  150.                 ckWS := ckWS^.Next;                    { Try the next one }
  151.             end;
  152.         end;
  153.  
  154.     RecPtr_Floating_window := nil;                    { No active one }
  155.  
  156.     end;
  157. end;
  158.  
  159. { ======================================================= }
  160.  
  161. { Routine: Resized_Floating_window }
  162. { Purpose: We were resized or zoomed, update the scrolling scrollbars }
  163.  
  164. procedure Resized_Floating_window(OldRect:Rect;whichWindow:WindowPtr);
  165. var
  166.     SavePort:WindowPtr;                                { Place to save the last port }
  167.     temp2Rect:Rect;                                { temp rectangle }
  168.     Index:integer;                                    { temp integer }
  169.     ScrollHandle:ControlHandle;
  170.     theWS:Floating_windowPRec;
  171.  
  172.  
  173. begin
  174. LocateInstance(whichWindow);
  175.  
  176. if (RecPtr_Floating_window <> nil) then                    { Only do if the window is us }
  177.     begin
  178.     theWS := RecPtr_Floating_window;
  179.     
  180.     GetPort(SavePort);                                { Save the current port }
  181.     SetPort(whichWindow);                            { Set the port to my window }
  182.  
  183.     U_ResizedFloating_window(theWS,OldRect);        { Call the user window resized routine }
  184.  
  185.     SetPort(SavePort);                                { Restore the old port }
  186.     end;
  187. end;
  188.  
  189. { ======================================================= }
  190.  
  191. { Routine: Update_Floating_window }
  192. { Purpose: Update our window }
  193.  
  194. procedure Update_Floating_window(whichWindow:WindowPtr);
  195. var
  196.     SavePort:WindowPtr;                            { Place to save the last port }
  197.     Saved_ForeColor:RGBColor;                    { Place to save colors }
  198.     Saved_BackColor:RGBColor;                    { Place to save colors }
  199.     DrawingColor:RGBColor;                        { Place to make colors }
  200.     theWS:Floating_windowPRec;
  201.  
  202.  
  203. begin
  204. LocateInstance(whichWindow);
  205.  
  206. if (RecPtr_Floating_window <> nil)    then                { Only do if the window is us }
  207.     begin
  208.     theWS := RecPtr_Floating_window;
  209.  
  210.     GetPort(SavePort);                            { Save the current port }
  211.     SetPort(whichWindow);                        { Set the port to my window }
  212.  
  213.     if (Has.ColorQD) then                                { See if color QuickDraw is around }
  214.         begin
  215.         GetForeColor(Saved_ForeColor);            { Save the fore color }
  216.         GetBackColor(Saved_BackColor);            { Save the back color }
  217.  
  218.         RGBForeColor(Black_ForeColor);            { Set the fore color to Black }
  219.         RGBBackColor(White_BackColor);            { Set the back color to White }
  220.         end;                                        { End of IF }
  221.  
  222.  
  223.  
  224.     if (Has.ColorQD) then                                { See if color QuickDraw is around }
  225.         begin
  226.         RGBForeColor(Saved_ForeColor);            { Restore the fore color }
  227.         RGBBackColor(Saved_BackColor);            { Restore the back color }
  228.         end;
  229.  
  230.  
  231.     TextFont(applFont);                            { Back to the application font }
  232.     TextSize(12);                                { Back to the application size }
  233.     TextFace([]);                                { Set text style }
  234.  
  235.     U_UpdateFloating_window(theWS);            { Call the user window update routine }
  236.  
  237.     SetPort(SavePort);                            { Restore the old port }
  238.     end;
  239. end;
  240.  
  241. { ======================================================= }
  242.  
  243. { Routine: Open_Floating_window }
  244. { Purpose: Open our window }
  245.  
  246. procedure Open_Floating_window;
  247. var
  248.     BehindWindow:WindowPtr;                            { Used for window placement }
  249.     theLong:longint;                                { Used for icons and hotspots definition }
  250.     DefaultPosition:Point;                        { Used for window placement }
  251.     theWS:Floating_windowPRec;
  252.  
  253.  
  254. begin
  255. if ((ListRecPtr_Floating_window = nil) or (MultipleAllowed_Floating_window)) then
  256.     begin
  257.     theWS := Floating_windowPRec(NewPtrClear(sizeof(Floating_windowRec)));
  258.     RecPtr_Floating_window := theWS;
  259.     theWS^.Next := ListRecPtr_Floating_window;
  260.     ListRecPtr_Floating_window := theWS;
  261.     
  262.     InitRecord(theWS);
  263.  
  264.     BehindWindow := Mk_BehindWindow(6);            { Get which window to place below }
  265.  
  266.     if (Has.ColorQD) then                                { See if color QuickDraw is around }
  267.         theWS^.theWindow := GetNewCWindow(ResW_Floating_window,nil,BehindWindow)    { Get the COLOR window from the resource file }
  268.     else
  269.         theWS^.theWindow := GetNewWindow(ResW_Floating_window,nil,BehindWindow);{ Get the window from the resource file }
  270.     Mk_RegisterWindow(theWS^.theWindow,6);    { Register the window with the layers }
  271.     SetPort(theWS^.theWindow);                        { Prepare to write into our window }
  272.  
  273.     { Make a Palette }
  274.     theWS^.Ctrl_Tool_palette2 := MakePalette(theWS^.theWindow,ResC_Tool_palette2,
  275.         theWS^.Enable_Tool_palette2,10,2,ResC_N_Tool_palette2,6);
  276.  
  277.     SetPort(theWS^.theWindow);                        { Select our window }
  278.     DefaultPosition.h := 0;                            { Reset Horz position }
  279.     DefaultPosition.v := 0;                            { Reset Vert position }
  280.     LocalToGlobal(DefaultPosition);                { Get global location }
  281.     PositionWindow(theWS^.theWindow,theWindowLocRec.Loc_Floating_window,DefaultPosition);
  282.  
  283.     U_OpenFloating_window(theWS);                    { Call the users window open routine }
  284.  
  285.     ShowWindow(theWS^.theWindow);                    { Show the window now }
  286.  
  287.     end
  288. else
  289.     theWS := ListRecPtr_Floating_window;
  290.  
  291. Mk_HiliteWindow(theWS^.theWindow);                    { Already open, so show it }
  292. end;
  293.  
  294. { ======================================================= }
  295.  
  296. { Routine: Activate_Floating_window }
  297. { Purpose: We activated or deactivated }
  298.  
  299. procedure Activate_Floating_window(whichWindow:WindowPtr;Do_An_Activate:Boolean);
  300. var
  301.     SavePort:WindowPtr;                                { Place to save the last port }
  302.     theWS:Floating_windowPRec;
  303.  
  304.  
  305. begin
  306. LocateInstance(whichWindow);
  307.  
  308. if (RecPtr_Floating_window <> nil) then                    { Only do if the window is us }
  309.     begin
  310.     theWS := RecPtr_Floating_window;
  311.  
  312.     GetPort(SavePort);                                { Save the current port }
  313.     SetPort(whichWindow);                            { Set the port to my window }
  314.  
  315.     if (not(Do_An_Activate)) then                    { Handle the deactivate }
  316.         begin
  317.         if (theInput <> nil) then                    { See if there is already a TE area }
  318.             TEDeactivate(theInput);                    { Yes, so turn it off }
  319.         theInput := nil;                                { Deactivate the TE area }
  320.         end
  321.     else
  322.         begin
  323.         end;
  324.  
  325.     U_ActivateFloating_window(theWS,Do_An_Activate);    { Call the user window activate routine }
  326.  
  327.     SetPort(SavePort);                                { Restore the old port }
  328.     end;
  329. end;
  330.  
  331. { ======================================================= }
  332.  
  333. { Routine: Do_A_Button }
  334. { Purpose: Handle a button pressed }
  335.  
  336. procedure Do_A_Button(theWS:Floating_windowPRec;theControl:ControlHandle);    { Handle a button being pressed }
  337. var
  338.     RefCon:longint;                                    { RefCon for controls }
  339.     UnHiliteValue:integer;                            { For unhilite }
  340.     theSelection:integer;                            { For palettes and popups }
  341.  
  342.  
  343. begin
  344. if (theWS <> nil) then                                { Only do if the window is us }
  345.     begin
  346.     HiliteControl(theControl,10);                        { Darken the button }
  347.     UnHiliteValue := 0;                                    { To lighten the button }
  348.     RefCon := GetCRefCon(theControl);                    { get control refcon }
  349.     
  350.     case (RefCon) of                                    { Select correct button }
  351.         -1:begin end;
  352.         ResC_Tool_palette2:                { Tool palette, Tool palette }
  353.             begin
  354.             theWS^.Value_Tool_palette2 := GetCtlValue(theWS^.Ctrl_Tool_palette2);{ Get the palette value, 0xrrcc, rr is row, cc is column }
  355.             end;
  356.     
  357.         otherwise                                    { allow other buttons, trap for debug }
  358.             begin
  359.             end;                                { end of otherwise }
  360.         end;                                            { end of switch }
  361.     
  362.     U_DoButtonFloating_window(theWS,RefCon,theControl,UnHiliteValue);{ Call to handle any extra user buttons }
  363.     
  364.     HiliteControl(theControl,UnHiliteValue);            { Lighten the button }
  365.     end;
  366.  
  367. end;                                                    { End of Handle a button being pressed }
  368.  
  369. { ======================================================= }
  370.  
  371. { Routine: Do_Floating_window }
  372. { Purpose: Handle action to our window, like controls }
  373.  
  374. procedure Do_Floating_window(var myEvent:EventRecord);
  375. var
  376.     code:integer;                            { Location of event in window or controls }
  377.     whichWindow:WindowPtr;                    { Window pointer where event happened }
  378.     myPt:Point;                            { Point where event happened }
  379.     theControl:ControlHandle;                        { Handle for a control }
  380.     theWS:Floating_windowPRec;
  381.  
  382.  
  383. begin
  384. theWS := nil;
  385.  
  386. code := FindWindow(myEvent.where,whichWindow);    { Get where in window and which window }
  387.  
  388. LocateInstance(whichWindow);
  389.  
  390. if (RecPtr_Floating_window <> nil) then                    { Only do if the window is us }
  391.     begin
  392.     theWS := RecPtr_Floating_window;
  393.  
  394.     U_DoEventFloating_window(theWS,myEvent);
  395.  
  396.     if (myEvent.what = mouseDown) then
  397.         begin
  398.         myPt := myEvent.where;                    { Get mouse position }
  399.         GlobalToLocal(myPt);                    { Make it relative }
  400.  
  401.         end;
  402.  
  403.     if ((theWS^.theWindow = whichWindow) and (code = inContent)) then    { for our window }
  404.         begin
  405.         myPt := myEvent.where;                    { Get mouse position }
  406.         GlobalToLocal(myPt);                    { Make it relative }
  407.  
  408.         code := FindControl(myPt,whichWindow,theControl);    { Get type of control }
  409.  
  410.         if (code <> 0) then                            { Check type of control }
  411.             code := TrackControl(theControl,myPt,ProcPtr(-1));{ Track the control }
  412.         if (code = inButton) then
  413.             Do_A_Button(theWS,theControl);            { Do buttons }
  414.  
  415.         end;
  416.     end;
  417. end;
  418.  
  419. { ======================================================= }
  420. { ======================================================= }
  421. end.
  422.